﻿
// ## 2022/12/11 # 铃 # 统合所有的运输功能的算法

namespace AI全局运输
{

	/// =========================================================================================

	const bool 调试模式 = false;
	const bool 调试模式2 = false;

	const int 分数 = 0;
	const int 金 = 1;
	const int 粮 = 2;
	const int 兵 = 3;
	const int 枪 = 4;
	const int 戟 = 5;
	const int 弩 = 6;
	const int 马 = 7;
	const int 兵器 = 8;
	const int 船 = 9;

	class Main
	{
		pk::list<pk::person @> actors;

		Main()
		{
			pk::bind(111, pk::trigger111_t(on_turn_start));
			pk::bind(202, pk::trigger202_t(onAIRunningOrder));
		}

		array<int> to_base_trans_troops(据点_末, 0); // 指向目标据点的运输兵力总数
		array<int> to_base_trans_unit(据点_末, 0); // 指向目标据点的运输队总数

		int base_id;


		void on_turn_start(pk::force @force)
		{
			reset_tranport(force);
		}



		//------------------------------------------------------------------------------------------------------------------------------
		//                                        据点运输
		//------------------------------------------------------------------------------------------------------------------------------

		//******************************************运输前判决**************************************
		void onAIRunningOrder(pk::ai_context @context, pk::building @building, int cmd)
		{
			if (cmd == 据点AI_据点运输 and pk::get_elapsed_months() > 6)
			{
				int building_force_id = building.get_force_id();
				pk::force @force = pk::get_force(building.get_force_id());
				pk::ai_context_base @base = context.base[building.get_id()];
				main.base_id = building.get_id();
				int neibor_enemy_base_count = ch::neibor_enemy_base_count(building, 1);

				if (pk::is_player_controlled(building))
					return;

				if (调试模式2)
					pk::trace(pk::format("{}0出发", pk::decode(pk::get_name(building))));
				if (ch::get_base_list(force).count == 1)
					return;
				if (pk::get_idle_person_list(building).count == 0)
					return;
				if (调试模式2)
					pk::trace(pk::format("{}1出发", pk::decode(pk::get_name(building))));

				if (building.energy < 120)
					return;

				if (ai::base_in_range_enemy_troops[building.get_id()] > 0)
					return;
				if (调试模式2)
					pk::trace(pk::format("{}2出发", pk::decode(pk::get_name(building))));

				int 运输兵力下限 = 10000;
				if (neibor_enemy_base_count >= 3) 运输兵力下限 = 50000;  //危险
				else if (neibor_enemy_base_count >= 1) 运输兵力下限 = 30000;  //前线
				else if (neibor_enemy_base_count == 0) 运输兵力下限 = 10000;  //后方
				else 运输兵力下限 = 10000;

				if (building.get_id() >= 城市_末) 运输兵力下限 /= 3;

				if ((pk::get_food(building) < 运输兵力下限 * 2 or pk::get_troops(building) < 运输兵力下限))
					return;

				if (调试模式2)
					pk::trace(pk::format("{}3出发", pk::decode(pk::get_name(building))));


				AI据点运输(force, building);
				ch::remove_idle_person(context, actors);
			}
		}

		//*****************************************据点运输计算**************************************
		void AI据点运输(pk::force @force, pk::building @building)
		{
			array<pk::building @> dst_base_arr = 寻找据点运输据点列表(building, force);

			if (dst_base_arr.length == 0)
				return;

		// 运输候选据点的优先顺序
			dst_base_arr.sort(function(a, b) { return ai::base_in_line_score[a.get_id()] > ai::base_in_line_score[b.get_id()]; });

			pk::building @dst_base = dst_base_arr[0];

			int 运输上限 = 20000;
			int 运输据点距离上限 = 3;

			int 目标剩余可运数量 = pk::get_max_troops(dst_base) - to_base_trans_troops[dst_base.get_id()] - pk::get_troops(dst_base);

			if (调试模式2)
				pk::trace(pk::format("{}从出发：目标{}：指向目标的运输队{}：目标剩余可运数量{},运输队数量{}", pk::decode(pk::get_name(building)), pk::decode(pk::get_name(dst_base)), to_base_trans_troops[dst_base.get_id()], 目标剩余可运数量, to_base_trans_unit[dst_base.get_id()]));

			if (目标剩余可运数量 < 5000)
				return;

			if (to_base_trans_unit[dst_base.get_id()] > 2)
				return;

			if (!pk::is_alive(dst_base))
				return;

			pk::list<pk::person @> person_list = pk::get_idle_person_list(building);
			if (person_list.count == 0)
				return;

			if (building.get_id() == dst_base.get_id())
				return;

			运输部队出征(building, dst_base);

			return;
		}


		//*****************************************运输执行计算出征**************************************
		void 运输部队出征(pk::building @src_base, pk::building @dst_base)
		{
			pk::force @force = pk::get_force(src_base.get_force_id());
			string dst_base_name = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(dst_base)));

			//********************分配计算法********************

			// ********************出发地资源计算********************
			array<array<int>> src_goods_list = {
				{分数, 0},
				{金, 0},
				{粮, 0},
				{兵, 0},
				{枪, 0},
				{戟, 0},
				{弩, 0},
				{马, 0},
				{兵器, 0},
				{船, 0} };

			src_goods_list[兵][1] = pk::get_troops(src_base);
			src_goods_list[金][1] = pk::get_gold(src_base);
			src_goods_list[粮][1] = pk::get_food(src_base);
			src_goods_list[枪][1] = pk::get_weapon_amount(src_base, 兵器_枪);
			src_goods_list[戟][1] = pk::get_weapon_amount(src_base, 兵器_戟);
			src_goods_list[弩][1] = pk::get_weapon_amount(src_base, 兵器_弩);
			src_goods_list[马][1] = pk::get_weapon_amount(src_base, 兵器_战马);
			src_goods_list[兵器][1] = pk::get_weapon_amount(src_base, 兵器_冲车) + pk::get_weapon_amount(src_base, 兵器_井阑) + pk::get_weapon_amount(src_base, 兵器_木兽) + pk::get_weapon_amount(src_base, 兵器_投石);
			src_goods_list[船][1] = pk::get_weapon_amount(src_base, 兵器_楼船) + pk::get_weapon_amount(src_base, 兵器_斗舰);

			// 目的地资源计算
			array<array<int>> dst_goods_list = {
				{分数, 0},
				{金, 0},
				{粮, 0},
				{兵, 0},
				{枪, 0},
				{戟, 0},
				{弩, 0},
				{马, 0},
				{兵器, 0},
				{船, 0} };

			dst_goods_list[兵][1] = pk::get_troops(dst_base);
			dst_goods_list[金][1] = pk::get_gold(dst_base);
			dst_goods_list[粮][1] = pk::get_food(dst_base);
			dst_goods_list[枪][1] = pk::get_weapon_amount(dst_base, 兵器_枪);
			dst_goods_list[戟][1] = pk::get_weapon_amount(dst_base, 兵器_戟);
			dst_goods_list[弩][1] = pk::get_weapon_amount(dst_base, 兵器_弩);
			dst_goods_list[马][1] = pk::get_weapon_amount(dst_base, 兵器_战马);
			dst_goods_list[兵器][1] = pk::get_weapon_amount(dst_base, 兵器_冲车) + pk::get_weapon_amount(dst_base, 兵器_井阑) + pk::get_weapon_amount(dst_base, 兵器_木兽) + pk::get_weapon_amount(dst_base, 兵器_投石);
			dst_goods_list[船][1] = pk::get_weapon_amount(dst_base, 兵器_楼船) + pk::get_weapon_amount(dst_base, 兵器_斗舰);


			//********************把指向目标的运输队的数据加入到目标城市数组中********************
			pk::list<pk::unit @> unit_list = pk::get_unit_list(force);
			for (int i = 0; i < unit_list.count; i++)
			{
				pk::unit @unit = unit_list[i];
				if (!pk::is_alive(unit))
					continue;
				if (unit.get_force_id() != src_base.get_force_id())
					continue;
				if (unit.type != 部队类型_运输)
					continue;
				if (!pk::is_valid_base_id(unit.target) or unit.target >= 据点_末)
					continue;
				if (unit.target == dst_base.get_id())
				{
					dst_goods_list[兵][1] += unit.troops;
					dst_goods_list[金][1] += unit.gold;
					dst_goods_list[粮][1] += unit.food;
					dst_goods_list[枪][1] += unit.stock[兵器_枪].amount;
					dst_goods_list[戟][1] += unit.stock[兵器_戟].amount;
					dst_goods_list[弩][1] += unit.stock[兵器_弩].amount;
					dst_goods_list[马][1] += unit.stock[兵器_战马].amount;
					dst_goods_list[兵器][1] += unit.stock[兵器_井阑].amount + unit.stock[兵器_冲车].amount + unit.stock[兵器_木兽].amount + unit.stock[兵器_投石].amount;
					dst_goods_list[船][1] += unit.stock[兵器_斗舰].amount + unit.stock[兵器_楼船].amount;
				}
			}

			//pk::trace(pk::format("{}到{} 出发分:{}，目的地分{}", pk::decode(pk::get_name(src_base)), dst_base_name, ai::base_in_line_score[src_base.get_id()], ai::base_in_line_score[dst_base.get_id()]));


				//********************对出发地打分********************
			src_goods_list[分数][1] = pk::max(2, ai::base_in_line_score[src_base.get_id()]);

			if (pk::get_max_troops(src_base) == pk::get_troops(src_base)) src_goods_list[分数][1] /= 2; //兵力满了的情况下,尽可能运出去,大幅降低自己的分数

			//********************对目标地打分********************
			dst_goods_list[分数][1] = pk::max(2, ai::base_in_line_score[dst_base.get_id()]);

			if (ai::base_in_range_enemy_troops[dst_base.get_id()] > 0) dst_goods_list[分数][1] /= 3;  //战斗状态很容易出现损失,因此尽量减少运输量.

			//pk::trace(pk::format("{}到{} 出发分:{}，目的地分{}", pk::decode(pk::get_name(src_base)), dst_base_name, src_goods_list[分数][1], dst_goods_list[分数][1]));

				//********************计算运输量*******************
			int 金运输量;
			int 粮运输量;
			int 兵运输量;

			int 分配留存金 = (src_goods_list[金][1] + dst_goods_list[金][1]) * src_goods_list[分数][1] / (src_goods_list[分数][1] + dst_goods_list[分数][1]);
			int 初始金运输量 = src_goods_list[金][1] - 分配留存金;
			金运输量 = pk::max(初始金运输量, 0);

			// 初始兵运输量,兵运输量不能直接赋值,要看看粮草的情况
			int 分配留存兵 = (src_goods_list[兵][1] + dst_goods_list[兵][1]) * src_goods_list[分数][1] / (src_goods_list[分数][1] + dst_goods_list[分数][1]);
			int 初始兵运输量 = pk::max(0, src_goods_list[兵][1] - 分配留存兵);


			// 初始粮运输量,粮运输量也不能直接赋值
			int 分配留存粮 = (src_goods_list[粮][1] + dst_goods_list[粮][1]) * src_goods_list[分数][1] / (src_goods_list[分数][1] + dst_goods_list[分数][1]);
			int 初始粮运输量 = pk::max(src_goods_list[粮][1] - 分配留存粮, 0);


			//pk::trace(pk::format("{}到{} 出发粮:{}，目的地粮{},运粮{}", pk::decode(pk::get_name(src_base)), dst_base_name, src_goods_list[粮][1], dst_goods_list[粮][1], 初始粮运输量));

				// 如果不需要运兵,只需要运粮或者金,则运输500兵,同时附带至少3000粮.
				// 重要:粮分为两块,一块是资源调度的粮,一块是为了达成本次运输而运输的粮.
			if (初始兵运输量 <= 500)
			{
				兵运输量 = 500;
				粮运输量 = pk::max(初始粮运输量, 3000);
			}

			// 如果需要运兵,此次运输则不运粮,不然陷入循环计算
			// 而且这时候需要考虑据点的粮够不够吃,如果不足,则倒推最大可运兵力.
			// 需要给运输队留下粮食
			else if (初始兵运输量 > 500)
			{
				// 如果据点兵力比较多,要提高粮留存量,1000兵25粮一个旬度,因此1年粮草为兵力/1000*25*36
				int 粮留存量 = pk::get_troops(src_base) / 1000 * 25 * 36;

				int 据点留存兵粮限制最大运输兵力 = (pk::get_food(src_base) - 粮留存量) * 10 / 2;
				兵运输量 = pk::min(初始兵运输量, 据点留存兵粮限制最大运输兵力);
				粮运输量 = 兵运输量 / 10 * 2;

				// 留下留存量,剩下的加到运输量里面去
				粮运输量 = 初始粮运输量;

			}

			//粮运输量需要有下限
			粮运输量 = pk::max(兵运输量 / 10 * 3, 粮运输量);

				// 不能撑满目标据点
			int 金运输量_最大值 = pk::max(0, pk::min(pk::get_gold(src_base), pk::get_max_gold(dst_base) - dst_goods_list[金][1])) + 1000;
			int 粮运输量_最大值 = pk::max(0, pk::min(pk::get_food(src_base), pk::get_max_food(dst_base) - dst_goods_list[粮][1])) + 兵运输量 / 10 * 3;
			int 兵运输量_最大值 = pk::max(0, pk::min(pk::get_troops(src_base), pk::get_max_troops(dst_base) - dst_goods_list[兵][1])) + 1000;

			// 避免意外情况损失惨重,每次运输都不超过上限

			金运输量_最大值 = pk::min(金运输量_最大值, 50000);
			粮运输量_最大值 = pk::min(粮运输量_最大值, 100000);
			兵运输量_最大值 = pk::min(兵运输量_最大值, 50000);

			if (dst_base.get_id() >= 城市_末)
			{
				金运输量_最大值 = pk::min(金运输量_最大值, 20000);
				粮运输量_最大值 = pk::min(粮运输量_最大值, 100000);
				兵运输量_最大值 = pk::min(兵运输量_最大值, 20000);
			}

			粮运输量 = pk::min(粮运输量_最大值, 粮运输量);
			金运输量 = pk::min(金运输量_最大值, 金运输量);
			兵运输量 = pk::max(pk::min(兵运输量_最大值, 兵运输量), 500);

			if (src_base.get_id() == 铃据点_上洛 and 调试模式2)
				pk::trace(pk::format("{}到{}金运输量：{}，粮运输量：{}，兵运输量：{}，兵运输量最大值：{}，目标预期兵：{}", pk::decode(pk::get_name(src_base)), dst_base_name, 金运输量, 粮运输量, 兵运输量, 兵运输量_最大值, dst_goods_list[兵][1]));

			if (src_base.get_id() == 铃据点_上洛 and 调试模式2)
				pk::trace(pk::format("{}到{}出发地分数：{}，目标分数：{}", pk::decode(pk::get_name(src_base)), dst_base_name, src_goods_list[分数][1], dst_goods_list[分数][1]));

			pk::com_deploy_cmd_info cmd;
			@cmd.base = @src_base;
			cmd.type = 部队类型_运输;

			// 兵装运输
			int 兵装运输量 = 0;
			int 兵装留存量 = 0;
			int 兵装运输量_最大值 = 0;
			int 总兵装运输量 = 0;

			for (int weapon_id = 兵器_枪; weapon_id <= 兵器_战马; weapon_id++)
			{
				int 分配留存兵装 = (pk::get_weapon_amount(src_base, weapon_id) + pk::get_weapon_amount(dst_base, weapon_id)) * src_goods_list[分数][1] / (src_goods_list[分数][1] + dst_goods_list[分数][1]);
				兵装运输量 = pk::max(pk::get_weapon_amount(src_base, weapon_id) - 分配留存兵装, 0);

				兵装运输量_最大值 = pk::get_max_weapon_amount(dst_base, weapon_id) - pk::get_weapon_amount(dst_base, weapon_id);
				兵装运输量_最大值 = pk::min(兵装运输量_最大值, ((dst_base.get_id() < 城市_末) ? 50000 : 20000));

				if (兵装运输量 > 兵装运输量_最大值)
					兵装运输量 = 兵装运输量_最大值;

				if (weapon_id <= 兵器_战马 and 兵装运输量 > 3000)
				{
					总兵装运输量 += 兵装运输量;
					cmd.weapon_id[weapon_id] = weapon_id;
					cmd.weapon_amount[weapon_id] = 兵装运输量;
				}
			}

			// 兵装运输
			int 兵器运输量 = 0;
			int 兵器留存量 = 0;
			int 兵器运输量_最大值 = 0;

			// 暂时分开考虑,每个10000兵需要1个兵器
			兵器留存量 = int((pk::get_troops(src_base) - 兵运输量) / 10000);

			for (int weapon_id = 兵器_冲车; weapon_id <= 兵器_斗舰; weapon_id++)
			{
				if (weapon_id == 兵器_走舸)
					continue;

				int 分配留存兵器 = (pk::get_weapon_amount(src_base, weapon_id) + pk::get_weapon_amount(dst_base, weapon_id)) * src_goods_list[分数][1] / (src_goods_list[分数][1] + dst_goods_list[分数][1]);
				兵器运输量 = pk::max(pk::get_weapon_amount(src_base, weapon_id) - 分配留存兵器, 0);
				兵装运输量_最大值 = pk::min(兵装运输量_最大值, ((dst_base.get_id() < 城市_末) ? 5 : 2));

				兵器运输量_最大值 = pk::get_max_weapon_amount(dst_base, weapon_id) - pk::get_weapon_amount(dst_base, weapon_id);

				if (兵器运输量 > 兵器运输量_最大值)
					兵器运输量 = 兵器运输量_最大值;

				if (兵器运输量 > 3 and weapon_id != 兵器_走舸)
				{
					cmd.weapon_id[weapon_id] = weapon_id;
					cmd.weapon_amount[weapon_id] = 兵器运输量;
				}
			}

			// 运输量太少也没必要
			int 总运输量 = 金运输量 + 粮运输量 / 10 + 兵运输量 + 总兵装运输量 / 5;

			//pk::trace(pk::format("{}到{}前置计算:金运输量：{}，粮运输量：{}，兵运输量：{},兵装运输量：{}，总运输量：{}", pk::decode(pk::get_name(src_base)), dst_base_name, 金运输量, 粮运输量, 兵运输量, 兵装运输量, 总运输量));
			int 运输阈值 = 30000;

			//目标特别缺的时候,能运一点是一点.
			//低阈值运输仅对大城有效
			if (dst_base.get_id() < 城市_末 and (dst_goods_list[兵][1] < 5000 or dst_goods_list[金][1] < 2000 or dst_goods_list[粮][1] < 20000))
				运输阈值 = 5000;

			if (总运输量 < 运输阈值)
				return;

			if (调试模式2)
				pk::trace(pk::format("{}到{}后置执行:金运输量：{}，粮运输量：{}，兵运输量：{},兵装运输量：{}，总运输量：{}", pk::decode(pk::get_name(src_base)), dst_base_name, 金运输量, 粮运输量, 兵运输量, 兵装运输量, 总运输量));


			//********************选择武将*******************
			pk::list<pk::person @> person_list = pk::get_idle_person_list(src_base);
			person_list.sort(function(a, b) {
				int a_skill = pk::has_skill(a, 特技_运输) ? 10000 : 0;
				int b_skill = pk::has_skill(b, 特技_运输) ? 10000 : 0;
				return ((a_skill)-int(a.kouseki) / 100) > ((b_skill)-int(b.kouseki) / 100);
			});

			cmd.member[0] = person_list[0].get_id();

			actors.add(person_list[0]);


			//********************运输队出征*******************
			cmd.food = 粮运输量;
			cmd.gold = 金运输量;
			cmd.troops = 兵运输量;
			cmd.order = 部队任务_移动;
			cmd.target_pos = dst_base.pos;
			int unit_id = pk::command(cmd);

			if (unit_id != -1)
			{
				pk::unit @unit = pk::get_unit(unit_id);
				unit.action_done = true;

				if (调试模式)
				{
					string unit_name3 = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(unit)));
					string src_base_name = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(src_base)));
					string dst_base_name2 = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(dst_base)));
					string action_message = pk::format("运输调度:{}从{}运输到{}", unit_name3, src_base_name, dst_base_name2);
					pk::trace(action_message);
				}
			}
		}


		//********************* 在运输部队出发的据点接壤的自势力据点中搜寻可运输的候选据点****************

		array<pk::building @> 寻找据点运输据点列表(pk::building @building, pk::force @force)
		{
			//每次清空数组
			for (int i = 0; i < 据点_末; i++)
			{
				to_base_trans_troops[i] = 0;
				to_base_trans_unit[i] = 0;
			}

			pk::list<pk::unit @> unit_list = pk::get_unit_list(force);
			for (int i = 0; i < unit_list.count; i++)
			{
				pk::unit @unit0 = unit_list[i];
				if (!pk::is_alive(unit0))
					continue;
				if (unit0.get_force_id() != building.get_force_id())
					continue;
				if (unit0.type != 部队类型_运输)
					continue;
				if (!pk::is_valid_base_id(unit0.target) or unit0.target >= 据点_末)
					continue;
				to_base_trans_troops[unit0.target] += unit0.troops;
				to_base_trans_unit[unit0.target]++;
			}

			array<pk::building @> dst_base_arr;
			for (int i = 0; i < 据点_末; i++)
			{

				int 运输据点距离上限 = 3;
				int 运输据点真实距离上限 = 10;

				pk::building @dst_base = pk::get_building(i);
				if (!pk::is_alive(dst_base))
					continue;

				if (dst_base.get_force_id() != building.get_force_id())
					continue;

				if (i == building.get_id())
					continue;

				int distanceToBuilding = pk::get_building_distance(building.get_id(), i, building.get_force_id());

				if (ch::neibor_enemy_base_count(building, 1) >= 1)
				{
					运输据点距离上限 = 1; //前线据点只允许向距离为1的据点运输
					运输据点真实距离上限 = 7;
				}

				if (distanceToBuilding > 运输据点距离上限)
					continue;


				if (unit_distance[building.get_id()][i] > 运输据点真实距离上限)
					continue;


				if (pk::get_troops(dst_base) * 1.0 > pk::get_max_troops(dst_base) * 0.8)
					continue;


				dst_base_arr.insertLast(dst_base);
			}

			return dst_base_arr;
		}

	//------------------------------------------------------------------------------------------------------------------------------
	//                                            运输队变更
	//------------------------------------------------------------------------------------------------------------------------------

	//*********************************************查找需要变更的运输队**************************************
		void reset_tranport(pk::force @force)
		{
			if (!pk::is_normal_force(force) or force.get_id() >= 势力_末 or force.get_id() < 0)
				return;

			pk::list<pk::unit @> unit_list = pk::get_unit_list(force);
			for (int i = 0; i < unit_list.count; i++)
			{
				pk::unit @unit = unit_list[i];
				if (!pk::is_alive(unit))
					continue;

				//  跳过非运输类型部队
				if (unit.type != 部队类型_运输)
					continue;

				if (pk::is_player_controlled(unit))
					continue;

				if ((unit.order == 部队任务_待命))
				{
					重设运输队目标(unit);
					continue;
				}

				if ((unit.target_type == 部队任务对象_据点) and pk::is_valid_base_id(unit.target) and unit.target < 据点_末)
				{
					if (unit.troops + pk::get_troops(pk::get_building(unit.target)) > pk::get_max_troops(pk::get_building(unit.target)) + 1000) //允许1000的冗余
						重设运输队目标(unit);
					continue;
				}
			}
		}

		//*********************************************变更运输队目标**************************************
		void 重设运输队目标(pk::unit @unit)
		{

			array<pk::building @> dst_base_arr = 获取运输队据点列表(unit);
			int dst_id;

			if (!pk::is_valid_person_id(unit.member[0])) return;

			if (dst_base_arr.length == 0)
			{
				pk::person@ leader = pk::get_person(unit.leader);
				dst_id = leader.service;
				if (dst_id < 0 or dst_id >据点_末)
					return;
				pk::set_order(unit, 部队任务_撤退, pk::get_building(leader.service).pos);
			}

			else
			{
				// 运输候选据点的优先顺序
				dst_base_arr.sort(function(a, b) { return ai::base_in_line_score[a.get_id()] > ai::base_in_line_score[b.get_id()]; });
				dst_id = dst_base_arr[0].get_id();

				pk::set_order(unit, 部队任务_补给, pk::get_building(dst_id).pos);
				if (unit.action_done == false) pk::run_order(unit);
				pk::set_action_done(unit, true);
			}

			pk::building @dst_base = pk::get_building(dst_id);

			if (pk::is_valid_person_id(unit.leader) and 调试模式)
			{
			//	pk::trace(pk::format("{}运输队ID,主将ID{}{}{}", unit.get_id(),unit.member[0],unit.member[1],unit.member[2]));

				string unit_name2 = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(pk::get_person(unit.leader))));
				string dst_base_name2 = pk::format("\x1b[1x{}\x1b[0x", pk::decode(pk::get_name(dst_base)));
				string action_message = pk::format("{}运输队修改运输任务到{}", unit_name2, dst_base_name2);
				pk::trace(action_message);
			}
			return;
		}

		//*********************************************运输队变更的目标的时候,查找据点**************************************
		array<pk::building @> 获取运输队据点列表(pk::unit @unit)
		{

			array<pk::building @> dst_base_arr;
			for (int i = 0; i < 据点_末; i++)
			{

				pk::building @dst_base = pk::get_building(i);

				if (!pk::is_alive(dst_base))
					continue;

				//满的据点跳过
				if (pk::get_troops(dst_base) + unit.troops > pk::get_max_troops(dst_base) + 1000)//允许1000的冗余
					continue;

				//太远不行
				if (pk::get_distance(dst_base.pos, unit.pos) > 30)
					continue;

				//判断势力
				if (dst_base.get_force_id() != unit.get_force_id())
					continue;

				dst_base_arr.insertLast(dst_base);
			}

			return dst_base_arr;
		}



	} Main main;

}